home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 1 / PC Actual CD 01.iso / f1 / cimb.arj / EPSON.C < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-03  |  6.8 KB  |  303 lines
  1. /*==============================================================================
  2.  
  3. FICHERO: EPSON.C
  4.  
  5. AUTOR: ANTONIO LADESA JURADO
  6.  
  7. FECHA: 24/6/94
  8.  
  9. DESCRIPCION:
  10.  
  11.     Fichero que contiene las estructuras, constantes, variables y funciones
  12.     internas y externas para la impresión de las imágenes en una impresora
  13.     EPSON FX-80 o compatible (o a fichero).
  14.  
  15. ==============================================================================*/
  16.  
  17.  
  18. /*---- MODULOS USADOS --------------------------------------------------------*/
  19.  
  20. #include <stdio.h>
  21. #include <conio.h>
  22. #include <dos.h>
  23. #include <string.h>
  24.  
  25. #include "global.h"
  26. #include "memoria.h"
  27. #include "video.h"
  28. #include "epson.h"
  29. #include "color.h"
  30. #include "escala.h"
  31. #include "error.h"
  32.  
  33. /*---- DEFINICION DE LAS FUNCIONES INTERNAS ----------------------------------*/
  34.  
  35.  
  36. void ImprimirCadena(char *s);
  37. void ImprimirCaracter(int c);
  38. void GrabarCadena(FILE *f,char *s);
  39. void GrabarCaracter(FILE *f,int c);
  40. int LeerBit(char *p,int n,int w);
  41.  
  42. /*---- CODIFICACION DE LAS FUNCIONES OFRECIDAS -------------------------------*/
  43.  
  44.  
  45. /*---- FUNCION: extern int EPSONimprimir(IMAGEN *c,char *nombre) ---------------
  46.  
  47.     Descripción:
  48.  
  49.         Esta función envía una imagen a la impresora EPSON FX-80 o
  50.         a un fichero.
  51.  
  52.     Parámetros:
  53.  
  54.         IMAGEN *c : puntero a estructura que alberga la imagen
  55.         char *nombre : nombre del fichero de salida (o cte = "IMPRESORA")
  56.  
  57.     Retorno:
  58.  
  59.         - 1 si hubo éxito.
  60.         - 0 si hubo error.
  61.  
  62. ---- CODIGO: -----------------------------------------------------------------*/
  63.  
  64. extern int EPSONimprimir(IMAGEN *c,char *nombre)
  65. {
  66.     /* buffer */
  67. char buffer[ANCHO_MAXIMO];
  68.     /* contadores */
  69. int i,j,a;
  70.     /* puntero a la imagen duplicada */
  71. IMAGEN *r=NULL;
  72.     /* puntero al fichero de salida */
  73. FILE *f;
  74.     /* factor de escalado */
  75. double factor;
  76.  
  77.     /* si no hay imagen, error */
  78. if(c==NULL)
  79.     {
  80.     ERRORponer(ERRnoImagen);
  81.     return(0);
  82.     }
  83.  
  84.     /* duplicar imagen para transformarla */
  85. if((r = IMAGENduplicar(c))!=NULL)
  86.     {
  87.     if(r->colores != 2)
  88.         {
  89.             /* si no tiene 256 colores, convertirla para obtener más calidad */
  90.         if(r->colores < 256)
  91.             {
  92.             r = EscalarColores(r,256);
  93.             ERRORver();
  94.             }
  95.             /* convertir a blanco y negro */
  96.         r = BlancoYNegro(r,FLOYD);
  97.         ERRORver();
  98.         }
  99.         /* si es muy grande, escalarla */
  100.     if(r->ancho > 640)
  101.         {
  102.         factor = (int)(64000.0/(double)r->ancho);
  103.         r = IMAGENescalar(r,factor,factor);
  104.         ERRORver();
  105.         }
  106.     }
  107. else
  108.     return(0);
  109.  
  110.     /* si el de stino es la impresora */
  111. if(!strcmp(nombre,"IMPRESORA"))
  112.     {
  113.             /* inicializar impresora */
  114.         ImprimirCadena("\x1b@");
  115.         for(i=0;i<r->alto;i+=8)
  116.             {
  117.                 /* imprimir caracteres de control */
  118.             ImprimirCadena("\x1b*\x06");
  119.             ImprimirCaracter(r->ancho);
  120.             ImprimirCaracter(r->ancho>>8);
  121.                 /* leer 8 líneas y convertir los bytes */
  122.             for(a=0;a<8;a++)
  123.                 if(a+i<r->alto)
  124.                     MEMleer(buffer+r->bytes*a,i+a,r);
  125.                 else
  126.                     memset(buffer+r->bytes*a,0xFF,r->bytes);
  127.                 /* imprimir las ocho líneas */
  128.             for(j=0;j<r->ancho;++j)
  129.                 ImprimirCaracter(~LeerBit(buffer,j,r->ancho));
  130.             ImprimirCadena("\r\x1bJ\x18");
  131.                 /* comprobar si se pulsó ESCAPE */
  132.             if(kbhit()) if(getch()==27) return(0);
  133.             }
  134.             /* inicializar impresora */
  135.         ImprimirCadena("\x1b@");
  136.     }
  137. else
  138.     {
  139.             /* abrir el fichero */
  140.         if((f = fopen(nombre, "wb")) == NULL)
  141.             {
  142.             ERRORponer(ERRapertura);
  143.             return(0);
  144.             }
  145.             /* escribir la imagen EPSON */
  146.         GrabarCadena(f,"\x1b@");
  147.         for(i=0;i<r->alto;i+=8)
  148.             {
  149.             GrabarCadena(f,"\x1b*\x06");
  150.             GrabarCaracter(f,r->ancho);
  151.             GrabarCaracter(f,r->ancho>>8);
  152.             for(a=0;a<8;a++)
  153.                 if(a+i<r->alto)
  154.                     MEMleer(buffer+r->bytes*a,i+a,c);
  155.                 else
  156.                     memset(buffer+r->bytes*a,0,r->bytes);
  157.             for(j=0;j<r->ancho;++j)
  158.                 GrabarCaracter(f,(~LeerBit(buffer,j,r->ancho)));
  159.             GrabarCadena(f,"\r\x1bJ\x18");
  160.             }
  161.         GrabarCadena(f,"\x1b@");
  162.             /* cerrar fichero */
  163.         fclose(f);
  164.     }
  165.     /* liberar imagen duplicada */
  166. r = MEMliberar(r);
  167. return(1);
  168. }
  169.  
  170. /*---- FIN FUNCION -----------------------------------------------------------*/
  171.  
  172.  
  173. /*---- CODIFICACION DE LAS FUNCIONES INTERNAS --------------------------------*/
  174.  
  175.  
  176. /*---- FUNCION: void ImprimirCadena(char *s) -----------------------------------
  177.  
  178.     Descripción:
  179.  
  180.         Esta función envía un conjunto de caracteres a la impresora.
  181.  
  182.     Parámetros:
  183.  
  184.         char *s : puntero a la cadena de caracteres
  185.  
  186. ---- CODIGO: -----------------------------------------------------------------*/
  187.  
  188. void ImprimirCadena(char *s)
  189. {
  190. while(*s) ImprimirCaracter(*s++);
  191. }
  192.  
  193. /*---- FIN FUNCION -----------------------------------------------------------*/
  194.  
  195.  
  196. /*---- FUNCION: void ImprimirCaracter(int c) -----------------------------------
  197.  
  198.     Descripción:
  199.  
  200.         Esta función envía un caracter a la impresora.
  201.  
  202.     Parámetros:
  203.  
  204.         int c : caracter a enviar
  205.  
  206. ---- CODIGO: -----------------------------------------------------------------*/
  207.  
  208. void ImprimirCaracter(int c)
  209. {
  210. union REGS r;
  211.  
  212.     /* esperar mientras la impresora no esté ocupada */
  213. do
  214.     {
  215.     r.h.ah = 2;
  216.     r.x.dx = 0;
  217.     int86(0x17,&r,&r);
  218.     }
  219. while(!(r.h.ah & 0x80));
  220.  
  221.     /* enviar caracter */
  222. r.h.ah = 0;
  223. r.h.al = c;
  224. r.x.dx = 0;
  225. int86(0x17,&r,&r);
  226. }
  227.  
  228. /*---- FIN FUNCION -----------------------------------------------------------*/
  229.  
  230.  
  231. /*---- FUNCION: void GrabarCadena(FILE *f,char *s) -----------------------------
  232.  
  233.     Descripción:
  234.  
  235.         Esta función envía una cadena de caracteres al fichero.
  236.  
  237.     Parámetros:
  238.  
  239.         FILE *f: puntero al fichero de salida.
  240.         char *s : cadena a enviar
  241.  
  242. ---- CODIGO: -----------------------------------------------------------------*/
  243.  
  244. void GrabarCadena(FILE *f,char *s)
  245. {
  246. while(*s) GrabarCaracter(f,*s++);
  247. }
  248.  
  249. /*---- FIN FUNCION -----------------------------------------------------------*/
  250.  
  251.  
  252. /*---- FUNCION: void GrabarCaracter(FILE *f,int c) -----------------------------
  253.  
  254.     Descripción:
  255.  
  256.         Esta función envía un caracter al fichero.
  257.  
  258.     Parámetros:
  259.  
  260.         FILE *f: puntero al fichero de salida.
  261.         int c : caracter a enviar
  262.  
  263. ---- CODIGO: -----------------------------------------------------------------*/
  264.  
  265. void GrabarCaracter(FILE *f,int c)
  266. {
  267. fprintf(f,"%c",c);
  268. }
  269.  
  270. /*---- FIN FUNCION -----------------------------------------------------------*/
  271.  
  272.  
  273. /*---- FUNCION: int LeerBit(char *p,int x,int ancho) -----------------------------
  274.  
  275.     Descripción:
  276.  
  277.         Esta función lee un bit de cada una de las 8 líneas, para conformar
  278.         el byte que imprimirá el cabezal de la impresora y lo devuelve.
  279.  
  280.     Parámetros:
  281.  
  282.         char *p : puntero al buffer que contiene la 8 líneas
  283.         int x : coordenada x a leer
  284.         int ancho: ancho de cada línea.
  285.  
  286. ---- CODIGO: -----------------------------------------------------------------*/
  287.  
  288. int LeerBit(char *p,int x,int ancho)
  289. {
  290. int b,i,r=0;
  291.  
  292. p+=(x/8);
  293.  
  294. for(i=7;i>=0;--i)
  295.     {
  296.     b= *p;
  297.     if(b & (1<<(7-x%8))) r |= (1 << i);
  298.     p+=(ancho/8);
  299.     }
  300. return(r);
  301. }
  302.  
  303. /*---- FIN FUNCION -----------------------------------------------------------*/